home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / lber.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-07-24  |  13.4 KB  |  632 lines
  1. /* $OpenLDAP: pkg/ldap/include/lber.h,v 1.94.2.6 2008/02/11 23:24:10 kurt Exp $ */
  2. /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  3.  *
  4.  * Copyright 1998-2008 The OpenLDAP Foundation.
  5.  * All rights reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted only as authorized by the OpenLDAP
  9.  * Public License.
  10.  *
  11.  * A copy of this license is available in file LICENSE in the
  12.  * top-level directory of the distribution or, alternatively, at
  13.  * <http://www.OpenLDAP.org/license.html>.
  14.  */
  15. /* Portions Copyright (c) 1990 Regents of the University of Michigan.
  16.  * All rights reserved.
  17.  *
  18.  * Redistribution and use in source and binary forms are permitted
  19.  * provided that this notice is preserved and that due credit is given
  20.  * to the University of Michigan at Ann Arbor. The name of the University
  21.  * may not be used to endorse or promote products derived from this
  22.  * software without specific prior written permission. This software
  23.  * is provided ``as is'' without express or implied warranty.
  24.  */
  25.  
  26. #ifndef _LBER_H
  27. #define _LBER_H
  28.  
  29. #include <lber_types.h>
  30. #include <string.h>
  31.  
  32. LDAP_BEGIN_DECL
  33.  
  34. /* Overview of LBER tag construction
  35.  *
  36.  *    Bits
  37.  *    ______
  38.  *    8 7 | CLASS
  39.  *    0 0 = UNIVERSAL
  40.  *    0 1 = APPLICATION
  41.  *    1 0 = CONTEXT-SPECIFIC
  42.  *    1 1 = PRIVATE
  43.  *        _____
  44.  *        | 6 | DATA-TYPE
  45.  *          0 = PRIMITIVE
  46.  *          1 = CONSTRUCTED
  47.  *            ___________
  48.  *            | 5 ... 1 | TAG-NUMBER
  49.  */
  50.  
  51. /* BER classes and mask */
  52. #define LBER_CLASS_UNIVERSAL    ((ber_tag_t) 0x00U)
  53. #define LBER_CLASS_APPLICATION    ((ber_tag_t) 0x40U)
  54. #define LBER_CLASS_CONTEXT        ((ber_tag_t) 0x80U)
  55. #define LBER_CLASS_PRIVATE        ((ber_tag_t) 0xc0U)
  56. #define LBER_CLASS_MASK            ((ber_tag_t) 0xc0U)
  57.  
  58. /* BER encoding type and mask */
  59. #define LBER_PRIMITIVE            ((ber_tag_t) 0x00U)
  60. #define LBER_CONSTRUCTED        ((ber_tag_t) 0x20U)
  61. #define LBER_ENCODING_MASK        ((ber_tag_t) 0x20U)
  62.  
  63. #define LBER_BIG_TAG_MASK        ((ber_tag_t) 0x1fU)
  64. #define LBER_MORE_TAG_MASK        ((ber_tag_t) 0x80U)
  65.  
  66. /*
  67.  * Note that LBER_ERROR and LBER_DEFAULT are values that can never appear
  68.  * as valid BER tags, and so it is safe to use them to report errors.  In
  69.  * fact, any tag for which the following is true is invalid:
  70.  */
  71. #define LBER_INVALID(t)     (((t) & (ber_tag_t) 0x080UL) \
  72.     && (((t) & (ber_tag_t) ~ 0x0FF))
  73.  
  74. #define LBER_ERROR            ((ber_tag_t) -1)
  75. #define LBER_DEFAULT        ((ber_tag_t) -1)
  76.  
  77. /* general BER types we know about */
  78. #define LBER_BOOLEAN        ((ber_tag_t) 0x01UL)
  79. #define LBER_INTEGER        ((ber_tag_t) 0x02UL)
  80. #define LBER_BITSTRING        ((ber_tag_t) 0x03UL)
  81. #define LBER_OCTETSTRING    ((ber_tag_t) 0x04UL)
  82. #define LBER_NULL            ((ber_tag_t) 0x05UL)
  83. #define LBER_ENUMERATED        ((ber_tag_t) 0x0aUL)
  84. #define LBER_SEQUENCE        ((ber_tag_t) 0x30UL)    /* constructed */
  85. #define LBER_SET            ((ber_tag_t) 0x31UL)    /* constructed */
  86.  
  87. /* LBER BerElement options */
  88. #define LBER_USE_DER        0x01
  89.  
  90. /* get/set options for BerElement */
  91. #define LBER_OPT_BER_OPTIONS            0x01
  92. #define LBER_OPT_BER_DEBUG                0x02
  93. #define LBER_OPT_BER_REMAINING_BYTES    0x03
  94. #define LBER_OPT_BER_TOTAL_BYTES        0x04
  95. #define LBER_OPT_BER_BYTES_TO_WRITE        0x05
  96. #define LBER_OPT_BER_MEMCTX                0x06
  97.  
  98. #define LBER_OPT_DEBUG_LEVEL    LBER_OPT_BER_DEBUG
  99. #define LBER_OPT_REMAINING_BYTES    LBER_OPT_BER_REMAINING_BYTES
  100. #define LBER_OPT_TOTAL_BYTES        LBER_OPT_BER_TOTAL_BYTES
  101. #define LBER_OPT_BYTES_TO_WRITE        LBER_OPT_BER_BYTES_TO_WRITE
  102.  
  103. #define LBER_OPT_LOG_PRINT_FN    0x8001
  104. #define LBER_OPT_MEMORY_FNS        0x8002
  105. #define LBER_OPT_ERROR_FN        0x8003
  106. #define LBER_OPT_LOG_PRINT_FILE        0x8004
  107.  
  108. /* get/set Memory Debug options */
  109. #define LBER_OPT_MEMORY_INUSE        0x8005    /* for memory debugging */
  110. #define LBER_OPT_LOG_PROC           0x8006  /* for external logging function */
  111.  
  112. typedef int* (*BER_ERRNO_FN) LDAP_P(( void ));
  113.  
  114. typedef void (*BER_LOG_PRINT_FN) LDAP_P(( LDAP_CONST char *buf ));
  115.  
  116. typedef void* (BER_MEMALLOC_FN)    LDAP_P(( ber_len_t size, void *ctx ));
  117. typedef void* (BER_MEMCALLOC_FN)    LDAP_P(( ber_len_t n, ber_len_t size, void *ctx ));
  118. typedef void* (BER_MEMREALLOC_FN)    LDAP_P(( void *p, ber_len_t size, void *ctx ));
  119. typedef void  (BER_MEMFREE_FN)        LDAP_P(( void *p, void *ctx ));
  120.  
  121. typedef struct lber_memory_fns {
  122.     BER_MEMALLOC_FN    *bmf_malloc;
  123.     BER_MEMCALLOC_FN *bmf_calloc;
  124.     BER_MEMREALLOC_FN *bmf_realloc;
  125.     BER_MEMFREE_FN *bmf_free;
  126. } BerMemoryFunctions;
  127.  
  128. /* LBER Sockbuf_IO options */
  129. #define LBER_SB_OPT_GET_FD        1
  130. #define LBER_SB_OPT_SET_FD        2
  131. #define LBER_SB_OPT_HAS_IO        3
  132. #define LBER_SB_OPT_SET_NONBLOCK    4
  133. #define LBER_SB_OPT_GET_SSL        7
  134. #define LBER_SB_OPT_DATA_READY        8
  135. #define LBER_SB_OPT_SET_READAHEAD    9
  136. #define LBER_SB_OPT_DRAIN        10
  137. #define LBER_SB_OPT_NEEDS_READ        11
  138. #define LBER_SB_OPT_NEEDS_WRITE        12
  139. #define LBER_SB_OPT_GET_MAX_INCOMING    13
  140. #define LBER_SB_OPT_SET_MAX_INCOMING    14
  141. /* Largest option used by the library */
  142. #define LBER_SB_OPT_OPT_MAX        14
  143.  
  144. /* LBER IO operations stacking levels */
  145. #define LBER_SBIOD_LEVEL_PROVIDER    10
  146. #define LBER_SBIOD_LEVEL_TRANSPORT    20
  147. #define LBER_SBIOD_LEVEL_APPLICATION    30
  148.  
  149. /* get/set options for Sockbuf */
  150. #define LBER_OPT_SOCKBUF_DESC        0x1000
  151. #define LBER_OPT_SOCKBUF_OPTIONS    0x1001
  152. #define LBER_OPT_SOCKBUF_DEBUG        0x1002
  153.  
  154. /* on/off values */
  155. LBER_V( char ) ber_pvt_opt_on;
  156. #define LBER_OPT_ON        ((void *) &ber_pvt_opt_on)
  157. #define LBER_OPT_OFF    ((void *) 0)
  158.  
  159. #define LBER_OPT_SUCCESS    (0)
  160. #define LBER_OPT_ERROR        (-1)
  161.  
  162. typedef struct berelement BerElement;
  163. typedef struct sockbuf Sockbuf;
  164. typedef struct seqorset Seqorset;
  165.  
  166. typedef struct sockbuf_io Sockbuf_IO;
  167.  
  168. /* Structure for LBER IO operarion descriptor */
  169. typedef struct sockbuf_io_desc {
  170.     int            sbiod_level;
  171.     Sockbuf            *sbiod_sb;
  172.     Sockbuf_IO        *sbiod_io;
  173.     void             *sbiod_pvt;
  174.     struct sockbuf_io_desc    *sbiod_next;
  175. } Sockbuf_IO_Desc;
  176.  
  177. /* Structure for LBER IO operation functions */
  178. struct sockbuf_io {
  179.     int (*sbi_setup)( Sockbuf_IO_Desc *sbiod, void *arg );
  180.     int (*sbi_remove)( Sockbuf_IO_Desc *sbiod );
  181.     int (*sbi_ctrl)( Sockbuf_IO_Desc *sbiod, int opt, void *arg);
  182.  
  183.     ber_slen_t (*sbi_read)( Sockbuf_IO_Desc *sbiod, void *buf,
  184.         ber_len_t len );
  185.     ber_slen_t (*sbi_write)( Sockbuf_IO_Desc *sbiod, void *buf,
  186.         ber_len_t len );
  187.  
  188.     int (*sbi_close)( Sockbuf_IO_Desc *sbiod );
  189. };
  190.  
  191. /* Helper macros for LBER IO functions */
  192. #define LBER_SBIOD_READ_NEXT( sbiod, buf, len ) \
  193.     ( (sbiod)->sbiod_next->sbiod_io->sbi_read( (sbiod)->sbiod_next, \
  194.         buf, len ) )
  195. #define LBER_SBIOD_WRITE_NEXT( sbiod, buf, len ) \
  196.     ( (sbiod)->sbiod_next->sbiod_io->sbi_write( (sbiod)->sbiod_next, \
  197.         buf, len ) )
  198. #define LBER_SBIOD_CTRL_NEXT( sbiod, opt, arg ) \
  199.     ( (sbiod)->sbiod_next ? \
  200.         ( (sbiod)->sbiod_next->sbiod_io->sbi_ctrl( \
  201.         (sbiod)->sbiod_next, opt, arg ) ) : 0 )
  202.  
  203. /* structure for returning a sequence of octet strings + length */
  204. typedef struct berval {
  205.     ber_len_t    bv_len;
  206.     char        *bv_val;
  207. } BerValue;
  208.  
  209. typedef BerValue *BerVarray;    /* To distinguish from a single bv */
  210.  
  211. /* this should be moved to lber-int.h */
  212.  
  213. /*
  214.  * in bprint.c:
  215.  */
  216. LBER_F( void )
  217. ber_error_print LDAP_P((
  218.     LDAP_CONST char *data ));
  219.  
  220. LBER_F( void )
  221. ber_bprint LDAP_P((
  222.     LDAP_CONST char *data, ber_len_t len ));
  223.  
  224. LBER_F( void )
  225. ber_dump LDAP_P((
  226.     BerElement *ber, int inout ));
  227.  
  228. LBER_F( void )
  229. ber_sos_dump LDAP_P((
  230.     Seqorset *sos ));
  231.  
  232. /*
  233.  * in decode.c:
  234.  */
  235. typedef int (*BERDecodeCallback) LDAP_P((
  236.     BerElement *ber,
  237.     void *data,
  238.     int mode ));
  239.  
  240. LBER_F( ber_tag_t )
  241. ber_get_tag LDAP_P((
  242.     BerElement *ber ));
  243.  
  244. LBER_F( ber_tag_t )
  245. ber_skip_tag LDAP_P((
  246.     BerElement *ber,
  247.     ber_len_t *len ));
  248.  
  249. LBER_F( ber_tag_t )
  250. ber_peek_tag LDAP_P((
  251.     BerElement *ber,
  252.     ber_len_t *len ));
  253.  
  254. LBER_F( ber_tag_t )
  255. ber_get_int LDAP_P((
  256.     BerElement *ber,
  257.     ber_int_t *num ));
  258.  
  259. LBER_F( ber_tag_t )
  260. ber_get_enum LDAP_P((
  261.     BerElement *ber,
  262.     ber_int_t *num ));
  263.  
  264. LBER_F( ber_tag_t )
  265. ber_get_stringb LDAP_P((
  266.     BerElement *ber,
  267.     char *buf,
  268.     ber_len_t *len ));
  269.  
  270. LBER_F( ber_tag_t )
  271. ber_get_stringbv LDAP_P((
  272.     BerElement *ber,
  273.     struct berval *bv,
  274.     int alloc ));
  275.  
  276. LBER_F( ber_tag_t )
  277. ber_get_stringa LDAP_P((
  278.     BerElement *ber,
  279.     char **buf ));
  280.  
  281. LBER_F( ber_tag_t )
  282. ber_get_stringal LDAP_P((
  283.     BerElement *ber,
  284.     struct berval **bv ));
  285.  
  286. LBER_F( ber_tag_t )
  287. ber_get_bitstringa LDAP_P((
  288.     BerElement *ber,
  289.     char **buf,
  290.     ber_len_t *len ));
  291.  
  292. LBER_F( ber_tag_t )
  293. ber_get_null LDAP_P((
  294.     BerElement *ber ));
  295.  
  296. LBER_F( ber_tag_t )
  297. ber_get_boolean LDAP_P((
  298.     BerElement *ber,
  299.     ber_int_t *boolval ));
  300.  
  301. LBER_F( ber_tag_t )
  302. ber_first_element LDAP_P((
  303.     BerElement *ber,
  304.     ber_len_t *len,
  305.     char **last ));
  306.  
  307. LBER_F( ber_tag_t )
  308. ber_next_element LDAP_P((
  309.     BerElement *ber,
  310.     ber_len_t *len,
  311.     LDAP_CONST char *last ));
  312.  
  313. LBER_F( ber_tag_t )
  314. ber_scanf LDAP_P((
  315.     BerElement *ber,
  316.     LDAP_CONST char *fmt,
  317.     ... ));
  318.  
  319. /*
  320.  * in encode.c
  321.  */
  322. typedef int (*BEREncodeCallback) LDAP_P((
  323.     BerElement *ber,
  324.     void *data ));
  325.  
  326. LBER_F( int )
  327. ber_put_enum LDAP_P((
  328.     BerElement *ber,
  329.     ber_int_t num,
  330.     ber_tag_t tag ));
  331.  
  332. LBER_F( int )
  333. ber_put_int LDAP_P((
  334.     BerElement *ber,
  335.     ber_int_t num,
  336.     ber_tag_t tag ));
  337.  
  338. LBER_F( int )
  339. ber_put_ostring LDAP_P((
  340.     BerElement *ber,
  341.     LDAP_CONST char *str,
  342.     ber_len_t len,
  343.     ber_tag_t tag ));
  344.  
  345. LBER_F( int )
  346. ber_put_berval LDAP_P((
  347.     BerElement *ber,
  348.     struct berval *bv,
  349.     ber_tag_t tag ));
  350.  
  351. LBER_F( int )
  352. ber_put_string LDAP_P((
  353.     BerElement *ber,
  354.     LDAP_CONST char *str,
  355.     ber_tag_t tag ));
  356.  
  357. LBER_F( int )
  358. ber_put_bitstring LDAP_P((
  359.     BerElement *ber,
  360.     LDAP_CONST char *str,
  361.     ber_len_t bitlen,
  362.     ber_tag_t tag ));
  363.  
  364. LBER_F( int )
  365. ber_put_null LDAP_P((
  366.     BerElement *ber,
  367.     ber_tag_t tag ));
  368.  
  369. LBER_F( int )
  370. ber_put_boolean LDAP_P((
  371.     BerElement *ber,
  372.     ber_int_t boolval,
  373.     ber_tag_t tag ));
  374.  
  375. LBER_F( int )
  376. ber_start_seq LDAP_P((
  377.     BerElement *ber,
  378.     ber_tag_t tag ));
  379.  
  380. LBER_F( int )
  381. ber_start_set LDAP_P((
  382.     BerElement *ber,
  383.     ber_tag_t tag ));
  384.  
  385. LBER_F( int )
  386. ber_put_seq LDAP_P((
  387.     BerElement *ber ));
  388.  
  389. LBER_F( int )
  390. ber_put_set LDAP_P((
  391.     BerElement *ber ));
  392.  
  393. LBER_F( int )
  394. ber_printf LDAP_P((
  395.     BerElement *ber,
  396.     LDAP_CONST char *fmt,
  397.     ... ));
  398.  
  399.  
  400. /*
  401.  * in io.c:
  402.  */
  403.  
  404. LBER_F( ber_slen_t )
  405. ber_read LDAP_P((
  406.     BerElement *ber,
  407.     char *buf,
  408.     ber_len_t len ));
  409.  
  410. LBER_F( ber_slen_t )
  411. ber_write LDAP_P((
  412.     BerElement *ber,
  413.     LDAP_CONST char *buf,
  414.     ber_len_t len,
  415.     int nosos ));
  416.  
  417. LBER_F( void )
  418. ber_free LDAP_P((
  419.     BerElement *ber,
  420.     int freebuf ));
  421.  
  422. LBER_F( void )
  423. ber_free_buf LDAP_P(( BerElement *ber ));
  424.  
  425. LBER_F( int )
  426. ber_flush LDAP_P((
  427.     Sockbuf *sb,
  428.     BerElement *ber,
  429.     int freeit ));
  430.  
  431. LBER_F( BerElement * )
  432. ber_alloc LDAP_P(( void )); /* DEPRECATED */
  433.  
  434. LBER_F( BerElement * )
  435. der_alloc LDAP_P(( void )); /* DEPRECATED */
  436.  
  437. LBER_F( BerElement * )
  438. ber_alloc_t LDAP_P((
  439.     int beroptions ));
  440.  
  441. LBER_F( BerElement * )
  442. ber_dup LDAP_P((
  443.     BerElement *ber ));
  444.  
  445. LBER_F( ber_tag_t )
  446. ber_get_next LDAP_P((
  447.     Sockbuf *sb,
  448.     ber_len_t *len,
  449.     BerElement *ber ));
  450.  
  451. LBER_F( void )
  452. ber_init2 LDAP_P((
  453.     BerElement *ber,
  454.     struct berval *bv,
  455.     int options ));
  456.  
  457. LBER_F( void )
  458. ber_init_w_nullc LDAP_P((    /* DEPRECATED */
  459.     BerElement *ber,
  460.     int options ));
  461.  
  462. LBER_F( void )
  463. ber_reset LDAP_P((
  464.     BerElement *ber,
  465.     int was_writing ));
  466.  
  467. LBER_F( BerElement * )
  468. ber_init LDAP_P((
  469.     struct berval *bv ));
  470.  
  471. LBER_F( int )
  472. ber_flatten LDAP_P((
  473.     BerElement *ber,
  474.     struct berval **bvPtr ));
  475.  
  476. LBER_F( int )
  477. ber_flatten2 LDAP_P((
  478.     BerElement *ber,
  479.     struct berval *bv,
  480.     int alloc ));
  481.  
  482. LBER_F( int )
  483. ber_remaining LDAP_P((
  484.     BerElement *ber ));
  485.  
  486. /*
  487.  * LBER ber accessor functions
  488.  */
  489.  
  490. LBER_F( int )
  491. ber_get_option LDAP_P((
  492.     void *item,
  493.     int option,
  494.     void *outvalue));
  495.  
  496. LBER_F( int )
  497. ber_set_option LDAP_P((
  498.     void *item,
  499.     int option,
  500.     LDAP_CONST void *invalue));
  501.  
  502. /*
  503.  * LBER sockbuf.c
  504.  */
  505.  
  506. LBER_F( Sockbuf *  )
  507. ber_sockbuf_alloc LDAP_P((
  508.     void ));
  509.  
  510. LBER_F( void )
  511. ber_sockbuf_free LDAP_P((
  512.     Sockbuf *sb ));
  513.  
  514. LBER_F( int )
  515. ber_sockbuf_add_io LDAP_P((
  516.     Sockbuf *sb,
  517.     Sockbuf_IO *sbio,
  518.     int layer,
  519.     void *arg ));
  520.  
  521. LBER_F( int )
  522. ber_sockbuf_remove_io LDAP_P((
  523.     Sockbuf *sb,
  524.     Sockbuf_IO *sbio,
  525.     int layer ));
  526.  
  527. LBER_F( int )
  528. ber_sockbuf_ctrl LDAP_P((
  529.     Sockbuf *sb,
  530.     int opt,
  531.     void *arg ));
  532.  
  533. LBER_V( Sockbuf_IO ) ber_sockbuf_io_tcp;
  534. LBER_V( Sockbuf_IO ) ber_sockbuf_io_readahead;
  535. LBER_V( Sockbuf_IO ) ber_sockbuf_io_fd;
  536. LBER_V( Sockbuf_IO ) ber_sockbuf_io_debug;
  537. LBER_V( Sockbuf_IO ) ber_sockbuf_io_udp;
  538.  
  539. /*
  540.  * LBER memory.c
  541.  */
  542. LBER_F( void * )
  543. ber_memalloc LDAP_P((
  544.     ber_len_t s ));
  545.  
  546. LBER_F( void * )
  547. ber_memrealloc LDAP_P((
  548.     void* p,
  549.     ber_len_t s ));
  550.  
  551. LBER_F( void * )
  552. ber_memcalloc LDAP_P((
  553.     ber_len_t n,
  554.     ber_len_t s ));
  555.  
  556. LBER_F( void )
  557. ber_memfree LDAP_P((
  558.     void* p ));
  559.  
  560. LBER_F( void )
  561. ber_memvfree LDAP_P((
  562.     void** vector ));
  563.  
  564. LBER_F( void )
  565. ber_bvfree LDAP_P((
  566.     struct berval *bv ));
  567.  
  568. LBER_F( void )
  569. ber_bvecfree LDAP_P((
  570.     struct berval **bv ));
  571.  
  572. LBER_F( int )
  573. ber_bvecadd LDAP_P((
  574.     struct berval ***bvec,
  575.     struct berval *bv ));
  576.  
  577. LBER_F( struct berval * )
  578. ber_dupbv LDAP_P((
  579.     struct berval *dst, struct berval *src ));
  580.  
  581. LBER_F( struct berval * )
  582. ber_bvdup LDAP_P((
  583.     struct berval *src ));
  584.  
  585. LBER_F( struct berval * )
  586. ber_mem2bv LDAP_P((
  587.     LDAP_CONST char *, ber_len_t len, int duplicate, struct berval *bv));
  588.  
  589. LBER_F( struct berval * )
  590. ber_str2bv LDAP_P((
  591.     LDAP_CONST char *, ber_len_t len, int duplicate, struct berval *bv));
  592.  
  593. #define    ber_bvstr(a)    ((ber_str2bv)((a), 0, 0, NULL))
  594. #define    ber_bvstrdup(a)    ((ber_str2bv)((a), 0, 1, NULL))
  595.  
  596. LBER_F( char * )
  597. ber_strdup LDAP_P((
  598.     LDAP_CONST char * ));
  599.  
  600. LBER_F( struct berval * )
  601. ber_bvreplace LDAP_P((
  602.     struct berval *dst, LDAP_CONST struct berval *src ));
  603.  
  604. LBER_F( void )
  605. ber_bvarray_free LDAP_P(( BerVarray p ));
  606.  
  607. LBER_F( int )
  608. ber_bvarray_add LDAP_P(( BerVarray *p, BerValue *bv ));
  609.  
  610. #define ber_bvcmp(v1,v2) \
  611.     ((v1)->bv_len < (v2)->bv_len \
  612.         ? -1 : ((v1)->bv_len > (v2)->bv_len \
  613.             ? 1 : memcmp((v1)->bv_val, (v2)->bv_val, (v1)->bv_len) ))
  614.  
  615. /*
  616.  * error.c
  617.  */
  618. LBER_F( int * ) ber_errno_addr LDAP_P((void));
  619. #define ber_errno (*(ber_errno_addr)())
  620.  
  621. #define LBER_ERROR_NONE        0
  622. #define LBER_ERROR_PARAM    0x1
  623. #define LBER_ERROR_MEMORY    0x2
  624.  
  625. #ifdef LDAP_DEVEL
  626. #define LDAP_NULL_IS_NULL
  627. #endif
  628.  
  629. LDAP_END_DECL
  630.  
  631. #endif /* _LBER_H */
  632.